package com.gitee.huanminabc.jcommon.str;

import com.gitee.huanminabc.jcommon.exception.CommonException;

/**
 * 简要描述
 *
 * @Author: huanmin
 * @Date: 2025/4/4 12:19
 * @Version: 1.0
 * @Description: 文件作用详细描述....
 */
public class StringCalculateUtil {

    //单个字符串的操作(自增(++),自减(--),取反(~),布尔取反(!),取绝对值(+),取负(-),向上取整(ceil),向下取整(floor),四舍五入(round)
    public static String strCalculateOne(String a, String symbol) {
        if (StringUtil.isEmpty(a)){
            throw new CommonException("参数不能为空");
        }
        //判断是否是数值
        if (StringIdentifyUtil.isNumeric(a)) {
            if ("++".equals(symbol)) { //自增
                return String.valueOf(Integer.parseInt(a) + 1);
            }
            if ("--".equals(symbol)) { //自减
                return String.valueOf(Integer.parseInt(a) - 1);
            }
            if ("~".equals(symbol)) { //按位取反
                return String.valueOf(~Integer.parseInt(a));
            }
            if ("-".equals(symbol)) { //取负

                if (a.charAt(0) != '-') { //如果不是负数
                    return String.valueOf(-Integer.parseInt(a));
                } else {
                    return a;
                }
            }
            if ("+".equals(symbol)) { //取绝对值
                return String.valueOf(Math.abs(Integer.parseInt(a)));
            }
            if (StringIdentifyUtil.isDecimal(a)) { //如果是小数
                if ("ceil".equals(symbol)) { //向上取整
                    return String.valueOf(Math.ceil(Double.parseDouble(a)));
                }
                if ("floor".equals(symbol)) { //向下取整
                    return String.valueOf(Math.floor(Double.parseDouble(a)));
                }
                if ("round".equals(symbol)) { //四舍五入
                    return String.valueOf(Math.round(Double.parseDouble(a)));
                }
            } else {//如果是整数
                return a;
            }
        }
        //判断是否是布尔值
        if (StringIdentifyUtil.isBoolean(a)) {
            if ("!".equals(symbol)) { //取反
                if ("true".equals(a)) {
                    return String.valueOf(false);
                }
                return String.valueOf(true);
            }
        }
        throw  new CommonException(symbol+"不支持的操作符");
    }

    //计算两个字符串的各种操作
    // 数值运算: 加(+) 减(-) 乘(*) 除(/) 取余(%) 自增(++) 自减(--)
    // 比较运算: 大于(>)、小于(<)、等于(==)、 大于等于(>=)、小于等于(<=)和不等于(!=)
    // 逻辑运算: 包括与(&&)、或(||)、非(!)
    // 位操作: 按位与(&)、按位或(|)、按位异或(^)、按位取反(~)
    public String strCalculateTwo(String a, String b, String symbol) {
        //判断是否是整数
        if (StringIdentifyUtil.isNumeric(a) && StringIdentifyUtil.isNumeric(b)) {
            if ("+".equals(symbol)) { //加
                if (StringIdentifyUtil.isNumeric(a) && StringIdentifyUtil.isNumeric(b)) {
                    return String.valueOf(Integer.parseInt(a) + Integer.parseInt(b));
                }
                return String.valueOf(Double.parseDouble(a) + Double.parseDouble(b));

            }
            if ("-".equals(symbol)) { //减
                if (StringIdentifyUtil.isNumeric(a) && StringIdentifyUtil.isNumeric(b)) {
                    return String.valueOf(Integer.parseInt(a) - Integer.parseInt(b));
                }
                return String.valueOf(Double.parseDouble(a) - Double.parseDouble(b));

            }
            if ("*".equals(symbol)) { //乘
                if (StringIdentifyUtil.isNumeric(a) && StringIdentifyUtil.isNumeric(b)) {

                    return String.valueOf(Integer.parseInt(a) * Integer.parseInt(b));
                }

                return String.valueOf(Double.parseDouble(a) * Double.parseDouble(b));

            }
            if ("/".equals(symbol)) { //除
                if (StringIdentifyUtil.isNumeric(a) && StringIdentifyUtil.isNumeric(b)) {
                    return String.valueOf(Integer.parseInt(a) / Integer.parseInt(b));
                }
                return String.valueOf(Double.parseDouble(a) / Double.parseDouble(b));
            }
            if ("%".equals(symbol)) { //取余
                if (StringIdentifyUtil.isNumeric(a) && StringIdentifyUtil.isNumeric(b)) {
                    return String.valueOf(Integer.parseInt(a) % Integer.parseInt(b));
                }
                return String.valueOf(Double.parseDouble(a) % Double.parseDouble(b));

            }
            if (">".equals(symbol)) { //大于
                if (StringIdentifyUtil.isNumeric(a) && StringIdentifyUtil.isNumeric(b)) {
                    return String.valueOf(Integer.parseInt(a) > Integer.parseInt(b));
                }
                return String.valueOf(Double.parseDouble(a) > Double.parseDouble(b));
            }

            if ("<".equals(symbol)) { //小于
                if (StringIdentifyUtil.isNumeric(a) && StringIdentifyUtil.isNumeric(b)) {
                    return String.valueOf(Integer.parseInt(a) < Integer.parseInt(b));
                }
                return String.valueOf(Double.parseDouble(a) < Double.parseDouble(b));
            }
            if ("==".equals(symbol)) { //等于
                if (StringIdentifyUtil.isNumeric(a) && StringIdentifyUtil.isNumeric(b)) {
                    return String.valueOf(Integer.parseInt(a) == Integer.parseInt(b));
                }
                return String.valueOf(Double.parseDouble(a) == Double.parseDouble(b));
            }
            if (">=".equals(symbol)) { //大于等于
                if (StringIdentifyUtil.isNumeric(a) && StringIdentifyUtil.isNumeric(b)) {
                    return String.valueOf(Integer.parseInt(a) >= Integer.parseInt(b));
                }
                return String.valueOf(Double.parseDouble(a) >= Double.parseDouble(b));
            }
            if ("<=".equals(symbol)) { //小于等于
                if (StringIdentifyUtil.isNumeric(a) && StringIdentifyUtil.isNumeric(b)) {
                    return String.valueOf(Integer.parseInt(a) <= Integer.parseInt(b));
                }
                return String.valueOf(Double.parseDouble(a) <= Double.parseDouble(b));
            }
            if ("!=".equals(symbol)) { //不等于
                if (StringIdentifyUtil.isNumeric(a) && StringIdentifyUtil.isNumeric(b)) {
                    return String.valueOf(Integer.parseInt(a) != Integer.parseInt(b));
                }
                return String.valueOf(Double.parseDouble(a) != Double.parseDouble(b));
            }

            if ("&".equals(symbol)) { //按位与
                return String.valueOf(Integer.parseInt(a) & Integer.parseInt(b));
            }
            if ("|".equals(symbol)) { //按位或
                return String.valueOf(Integer.parseInt(a) | Integer.parseInt(b));
            }
            if ("^".equals(symbol)) { //按位异或
                return String.valueOf(Integer.parseInt(a) ^ Integer.parseInt(b));
            }
            if ("<<".equals(symbol)) { //左移
                return String.valueOf(Integer.parseInt(a) << Integer.parseInt(b));
            }
            if (">>".equals(symbol)) { //右移
                return String.valueOf(Integer.parseInt(a) >> Integer.parseInt(b));
            }
        }

        if (StringIdentifyUtil.isBoolean(a) && StringIdentifyUtil.isBoolean(b)) {
            if ("&&".equals(symbol)) { //与
                return String.valueOf(Boolean.parseBoolean(a) && Boolean.parseBoolean(b));
            }
            if ("||".equals(symbol)) { //或
                return String.valueOf(Boolean.parseBoolean(a) || Boolean.parseBoolean(b));
            }
        }
        return null;
    }

}
